// pages/carpoolDetail/carpoolDetail.js
const api = require('../../config/api.js');
const util = require('../../utils/util.js');
const shareCard = require('../../utils/shareCard.js');

Page({

  /**
   * 页面的初始数据
   */
  data: {
    // 拼车详情ID
    carpoolId: null,
    // 当前登录用户信息
    currentUserInfo: null,
    // 用户信息
    userInfo: {
      nickName: '',
      imageUrl: '',
      skillIcons: [
        // 'https://static.codia.ai/image/2025-10-18/H7aWiQrJuy.png',
        // 'https://static.codia.ai/image/2025-10-18/e87WSdUDhD.png',
        // 'https://static.codia.ai/image/2025-10-18/RFYhV85GQm.png'
      ],
      badge: 'https://static.codia.ai/image/2025-10-18/brc82VU2Ho.png'
    },
    // 行程信息
    tripInfo: {
      type: '前往雪场',
      serviceType: '车找人',
      time: '后天 周六 10:00',
      departure: '前门大街',
      destination: '云顶大酒店',
      capacity: '1人·1雪板·1板包',
      price: '¥ 111/人',
      description: '禁止携带宠物，禁止吸烟，。如微信联系不上，直接电话沟通'
    },
    // 俱乐部信息
    clubInfo: {
      icon: 'https://static.codia.ai/image/2025-10-18/bgQwsUMpWh.png',
      text: '俱乐部成员优先展示'
    },
    // 注意事项
    terms: `1. 添加联系人时，请备注"滑雪去"小程序，明确来意。
2. 若行程时间有变动，需主动提前联系对方，避免耽误双方行程安排。
3. 拼车信息确认满人后，建议立即下架，防止因人员超额导致纠纷。
4. 临近出发时间，务必与对方二次确认能否按时出发，确保行程顺利。
5. 请遵守约定，避免爽约；若遭遇对方爽约，可联系管理员进行投诉，多次爽约者将被限制发布信息权限。`,
    // 风险须知
    riskNotice: {
      icon: 'https://static.codia.ai/image/2025-10-18/L8TnoFZ3a8.png',
      text: '风险须知'
    },
    // 收藏状态
    isFavorited: false,
    // 风险须知弹窗显示状态
    showRiskNoticePopup: false,
    // 联系方式弹窗显示状态
    showContactPopup: false,
    // 原始车信息（包含联系方式）
    carInfo: null,
    // 判断是否有经纬度信息，用于控制样式和点击事件
    hasDepartureLocation: false,
    hasDestinationLocation: false,
    // 倒计时相关
    countdown: '', // 倒计时显示文本（几分几秒）
    countdownTimer: null, // 倒计时定时器
    // 分享卡片图片路径（缓存）
    shareCardImageUrl: ''
  },

  /**
   * 生命周期函数--监听页面加载
   */
  onLoad: function (options) {
    // 获取当前登录用户信息
    this.loadCurrentUserInfo();
    
    // 从页面参数获取拼车详情ID
    if (options.id) {
      this.setData({
        carpoolId: options.id
      });
      this.loadCarpoolDetail(options.id);
    }
  },

  /**
   * 加载当前登录用户信息
   */
  loadCurrentUserInfo: function() {
    const userInfo = wx.getStorageSync('userInfo');
    if (userInfo) {
      this.setData({
        currentUserInfo: userInfo
      });
    }
  },

  /**
   * 格式化时间戳为可读日期（支持goTime字段）
   */
  formatDate: function(timestamp, goTime) {
    if (!timestamp) return '时间待定';
    
    try {
      // 判断是秒级时间戳还是毫秒级时间戳，或者是日期字符串
      let date;
      if (typeof timestamp === 'string') {
        // 如果是日期字符串，如 "2024-01-01"
        date = new Date(timestamp);
      } else {
        date = timestamp < 10000000000 ? new Date(timestamp * 1000) : new Date(timestamp);
      }
      
      // 验证日期是否有效
      if (isNaN(date.getTime())) {
        return '时间待定';
      }
      
      const now = new Date();
      const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
      const tomorrow = new Date(today.getTime() + 24 * 60 * 60 * 1000);
      const dayAfterTomorrow = new Date(today.getTime() + 2 * 24 * 60 * 60 * 1000);
      
      const targetDate = new Date(date.getFullYear(), date.getMonth(), date.getDate());
      
      let prefix = '';
      if (targetDate.getTime() === today.getTime()) {
        prefix = '今天';
      } else if (targetDate.getTime() === tomorrow.getTime()) {
        prefix = '明天';
      } else if (targetDate.getTime() === dayAfterTomorrow.getTime()) {
        prefix = '后天';
      } else {
        const month = date.getMonth() + 1;
        const day = date.getDate();
        const dayNames = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
        const dayName = dayNames[date.getDay()];
        // 如果有goTime，使用goTime；否则不显示时间
        if (goTime) {
          return `${month}.${day} ${dayName} ${goTime}`;
        }
        return `${month}.${day} ${dayName}`;
      }
      
      // 如果有goTime，使用goTime；否则使用从日期对象中提取的时间
      const timeStr = goTime || 
        `${date.getHours().toString().padStart(2, '0')}:${date.getMinutes().toString().padStart(2, '0')}`;
      return `${prefix} ${timeStr}`;
    } catch (error) {
      console.error('时间格式化失败:', error);
      return '时间待定';
    }
  },

  /**
   * 计算倒计时（几分几秒）
   */
  calculateCountdown: function(date, goTime) {
    if (!date || !goTime) {
      return '';
    }
    
    try {
      // 解析日期
      let dateObj;
      if (typeof date === 'string') {
        dateObj = new Date(date);
      } else {
        dateObj = date < 10000000000 ? new Date(date * 1000) : new Date(date);
      }
      
      // 解析goTime（格式：HH:mm）
      const [hours, minutes] = goTime.split(':').map(Number);
      if (isNaN(hours) || isNaN(minutes)) {
        return '';
      }
      
      // 设置目标时间（日期 + goTime）
      const targetTime = new Date(dateObj);
      targetTime.setHours(hours, minutes, 0, 0);
      
      // 计算时间差（毫秒）
      const now = new Date();
      const diff = targetTime.getTime() - now.getTime();
      
      // 如果已经过了出发时间，返回空字符串
      if (diff <= 0) {
        return '';
      }
      
      // 计算分钟和秒数
      const totalSeconds = Math.floor(diff / 1000);
      const mins = Math.floor(totalSeconds / 60);
      const secs = totalSeconds % 60;
      
      return `${mins}分${secs}秒`;
    } catch (error) {
      console.error('计算倒计时失败:', error);
      return '';
    }
  },

  /**
   * 启动倒计时定时器
   */
  startCountdownTimer: function() {
    // 清除之前的定时器
    if (this.data.countdownTimer) {
      clearInterval(this.data.countdownTimer);
    }
    
    const that = this;
    const carInfo = this.data.carInfo;
    
    if (!carInfo || !carInfo.date || !carInfo.goTime) {
      return;
    }
    
    // 立即计算一次
    const countdown = this.calculateCountdown(carInfo.date, carInfo.goTime);
    this.setData({
      countdown: countdown
    });
    
    // 如果倒计时为空（已过期），不启动定时器
    if (!countdown) {
      return;
    }
    
    // 每秒更新一次
    const timer = setInterval(function() {
      const countdown = that.calculateCountdown(carInfo.date, carInfo.goTime);
      that.setData({
        countdown: countdown
      });
      
      // 如果倒计时结束，清除定时器
      if (!countdown) {
        clearInterval(timer);
        that.setData({
          countdownTimer: null
        });
      }
    }, 1000);
    
    this.setData({
      countdownTimer: timer
    });
  },

  /**
   * 停止倒计时定时器
   */
  stopCountdownTimer: function() {
    if (this.data.countdownTimer) {
      clearInterval(this.data.countdownTimer);
      this.setData({
        countdownTimer: null
      });
    }
  },

  /**
   * 生命周期函数--监听页面初次渲染完成
   */
  onReady: function () {

  },

  /**
   * 生命周期函数--监听页面显示
   */
  onShow: function () {
    // 页面显示时重新启动倒计时定时器
    if (this.data.carInfo && this.data.carInfo.date && this.data.carInfo.goTime) {
      this.startCountdownTimer();
    }
  },

  /**
   * 生命周期函数--监听页面隐藏
   */
  onHide: function () {
    // 页面隐藏时停止倒计时定时器（节省资源）
    this.stopCountdownTimer();
  },

  /**
   * 生命周期函数--监听页面卸载
   */
  onUnload: function () {
    // 清除倒计时定时器
    this.stopCountdownTimer();
  },

  /**
   * 页面相关事件处理函数--监听用户下拉动作
   */
  onPullDownRefresh: function () {

  },

  /**
   * 页面上拉触底事件的处理函数
   */
  onReachBottom: function () {

  },

  /**
   * 生成分享卡片（预生成并缓存）
   */
  generateShareCard: function() {
    const that = this;
    const { tripInfo, carpoolId } = this.data;
    
    if (!tripInfo || !carpoolId) {
      return Promise.resolve();
    }
    
    // 异步生成分享卡片
    return shareCard.getShareCard('carpool', {
      id: carpoolId,
      carpoolId: carpoolId,
      tripInfo: tripInfo
    }).then((shareConfig) => {
      // 缓存分享卡片图片路径
      that.setData({
        shareCardImageUrl: shareConfig.imageUrl
      });
      // 返回分享配置，供调用方使用
      return shareConfig;
    }).catch((err) => {
      console.error('生成分享卡片失败:', err);
      // 失败时使用基础图
      const fallbackConfig = {
        imageUrl: '/static/images/shareBase.png'
      };
      that.setData({
        shareCardImageUrl: fallbackConfig.imageUrl
      });
      return fallbackConfig;
    });
  },

  /**
   * 用户点击右上角分享
   */
  onShareAppMessage: async function () {
    const { tripInfo, carpoolId, shareCardImageUrl } = this.data;
    
    // 获取分享配置
    const shareConfig = shareCard.getShareConfig('carpool', {
      id: carpoolId,
      carpoolId: carpoolId,
      tripInfo: tripInfo
    });
    
    // 如果没有缓存的分享卡片，显示loading并同步等待生成完成
    if (!shareCardImageUrl) {
      wx.showLoading({
        title: '生成分享卡片中...',
        mask: true
      });
      try {
        // 同步等待分享卡片生成完成，并获取返回的分享配置
        const generatedConfig = await this.generateShareCard();
        // 使用生成的分享卡片图片
        shareConfig.imageUrl = generatedConfig?.imageUrl || '/static/images/shareBase.png';
      } catch (err) {
        console.error('生成分享卡片失败:', err);
        shareConfig.imageUrl = '/static/images/shareBase.png';
      } finally {
        wx.hideLoading();
      }
    } else {
      // 使用缓存的分享卡片图片
      shareConfig.imageUrl = shareCardImageUrl;
    }
    
    return shareConfig;
  },

  /**
   * 返回上一页
   */
  goBack: function() {
    wx.navigateBack({
      delta: 1
    });
  },

  /**
   * 加入俱乐部
   */
  joinClub: function() {
    wx.navigateTo({
      url: '/pages/clubJoin/clubJoin',
      success: function() {
        console.log('跳转到加入俱乐部页面成功');
      },
      fail: function(err) {
        console.error('跳转到加入俱乐部页面失败:', err);
        wx.showToast({
          title: '页面跳转失败',
          icon: 'none'
        });
      }
    });
  },

  /**
   * 收藏/取消收藏
   */
  toggleFavorite: function() {
    const that = this;
    const carpoolId = this.data.carpoolId;
    
    if (!carpoolId) {
      wx.showToast({
        title: '数据错误',
        icon: 'none'
      });
      return;
    }

    const isFavorited = !this.data.isFavorited;
    
    // 调用收藏API
    util.request(api.UserSave, {
      id: parseInt(carpoolId),
      type: 0  // 0:拼车 1:拼房 2:雪票
    }, 'POST', 'application/json').then((res) => {
      console.log('收藏API响应:', res);
      
      const normalizedRes = util.normalizeApiResponse(res);
      
      if (normalizedRes.success) {
        that.setData({
          isFavorited: isFavorited
        });
        
        wx.showToast({
          title: isFavorited ? '已收藏' : '已取消收藏',
          icon: 'success'
        });
        
        // 重新加载详情数据以获取最新的收藏状态
        that.loadCarpoolDetail(carpoolId);
      } else {
        wx.showToast({
          title: normalizedRes.message || '操作失败',
          icon: 'none'
        });
      }
    }).catch((err) => {
      console.error('收藏API请求失败:', err);
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none'
      });
    });
  },

  /**
   * 显示联系方式弹窗（带登录校验）
   */
  showContactPopup: function() {
    const util = require('../../utils/util.js');
    
    // 检查是否已登录
    if (!util.checkUserLogin()) {
      util.showLoginModal('此操作需要先登录，是否立即登录？', () => {
        util.navigateToLogin();
      });
      return;
    }
    
    this.setData({
      showContactPopup: true
    });
  },

  /**
   * 关闭联系方式弹窗
   */
  closeContactPopup: function() {
    this.setData({
      showContactPopup: false
    });
  },

  /**
   * 阻止事件冒泡
   */
  stopPropagation: function() {
    // 阻止弹窗内容区域的点击事件冒泡
  },

  /**
   * 复制微信号
   */
  copyWechat: function() {
    const carInfo = this.data.carInfo;
    
    if (!carInfo || !carInfo.wechat) {
      wx.showToast({
        title: '暂无微信号',
        icon: 'none'
      });
      return;
    }

    // 确保微信号是字符串类型
    const wechatStr = String(carInfo.wechat || '').trim();
    
    if (!wechatStr) {
      wx.showToast({
        title: '暂无微信号',
        icon: 'none'
      });
      return;
    }

    wx.setClipboardData({
      data: wechatStr,
      success: () => {
        wx.showToast({
          title: '微信号已复制',
          icon: 'success'
        });
      },
      fail: (err) => {
        console.error('复制微信号失败:', err);
        wx.showToast({
          title: '复制失败，请重试',
          icon: 'none'
        });
      }
    });
  },

  /**
   * 复制手机号
   */
  copyPhone: function() {
    const carInfo = this.data.carInfo;
    
    if (!carInfo || !carInfo.phone) {
      wx.showToast({
        title: '暂无手机号',
        icon: 'none'
      });
      return;
    }

    // 确保手机号是字符串类型
    const phoneStr = String(carInfo.phone || '').trim();
    
    if (!phoneStr) {
      wx.showToast({
        title: '暂无手机号',
        icon: 'none'
      });
      return;
    }

    wx.setClipboardData({
      data: phoneStr,
      success: () => {
        wx.showToast({
          title: '手机号已复制',
          icon: 'success'
        });
      },
      fail: (err) => {
        console.error('复制手机号失败:', err);
        wx.showToast({
          title: '复制失败，请重试',
          icon: 'none'
        });
      }
    });
  },

  /**
   * 加载拼车详情
   */
  loadCarpoolDetail: function(id) {
    console.log('加载拼车详情:', id);
    
    // 显示加载提示
    wx.showLoading({
      title: '加载中...'
    });
    
    // 调用拼车详情API
    util.request(api.CarInfo, {
      id: parseInt(id)
    }, 'POST', 'application/json').then((res) => {
      wx.hideLoading();
      
      console.log('拼车详情API响应:', res);
      
      // 标准化API响应
      const normalizedRes = util.normalizeApiResponse(res);
      
      if (normalizedRes.success && normalizedRes.data) {
        // 更新页面数据
        this.updateCarpoolDetailData(normalizedRes.data);
        
      } else {
        // API调用失败
        wx.showToast({
          title: normalizedRes.message || '加载失败',
          icon: 'none',
          duration: 2000
        });
        
        // 使用模拟数据作为备选
        this.updateCarpoolDetailData(id);
      }
    }).catch((err) => {
      wx.hideLoading();
      console.error('拼车详情API调用失败:', err);
      
      wx.showToast({
        title: '网络错误，请重试',
        icon: 'none',
        duration: 2000
      });
      
      // 使用模拟数据作为备选
      this.updateCarpoolDetailData(id);
    });
  },

  /**
   * 根据API响应数据更新拼车详情数据
   */
  updateCarpoolDetailData: function(carInfo) {
    console.log('更新拼车详情数据:', carInfo);
    
    // 处理API返回的数据
    if (carInfo && typeof carInfo === 'object') {
      // 根据API响应格式更新页面数据
      // 处理出发地点显示：如果有locationName，分离主地址和详细地址
      // side=0 (前往): 出发地点用地图，longitude/latitude/locationName 属于出发地点
      const departureMain = carInfo.fromAddr || "出发地待定";
      const departureDetail = (carInfo.side === 0 && carInfo.locationName) ? carInfo.locationName : null;
      
      // 处理到达地点显示：如果有locationName，分离主地址和详细地址
      // side=1 (返回): 到达地点用地图，longitude/latitude/locationName 属于到达地点
      const destinationMain = carInfo.toAddr || "目的地待定";
      const destinationDetail = (carInfo.side === 1 && carInfo.locationName) ? carInfo.locationName : null;
      
      const tripInfo = {
        type: carInfo.side === 0 ? "前往雪场" : "雪场返回",
        serviceType: carInfo.type === 0 ? "车找人" : "人找车",
        time: this.formatDate(carInfo.date, carInfo.goTime) || "时间待定",
        departure: departureMain,
        departureDetail: departureDetail,
        destination: destinationMain,
        destinationDetail: destinationDetail,
        capacity: `${carInfo.people || 0}人·${carInfo.ski || 0}雪板·${
          carInfo.bag || 0
        }板包`,
        price: `¥ ${carInfo.price || 0}/人`,
        description: carInfo.detail || "暂无详细描述"
      };
      
      const userInfo = {
        nickName: carInfo.nickName,
        imageUrl: carInfo.imageUrl,
        skillIcons: [
          // 'https://static.codia.ai/image/2025-10-18/H7aWiQrJuy.png',
          // 'https://static.codia.ai/image/2025-10-18/e87WSdUDhD.png',
          // 'https://static.codia.ai/image/2025-10-18/RFYhV85GQm.png'
        ],
        badge: 'https://static.codia.ai/image/2025-10-18/brc82VU2Ho.png'
      };
      
      const clubInfo = {
        icon: 'https://static.codia.ai/image/2025-10-18/bgQwsUMpWh.png',
        text: carInfo.isClub === 1 ? '俱乐部成员优先展示' : '普通用户'
      };
      
      // 更新页面数据
      this.setData({
        tripInfo: tripInfo,
        userInfo: userInfo,
        clubInfo: clubInfo,
        // 保存原始数据供其他功能使用（包括联系方式、地图坐标等）
        // 根据side判断地图选点信息属于哪个地点
        // side=0 (前往): 出发地点用地图，longitude/latitude/locationName 属于出发地点
        // side=1 (返回): 到达地点用地图，longitude/latitude/locationName 属于到达地点
        carInfo: {
          wechat: carInfo.wechat || '',
          phone: carInfo.phone || '',
          date: carInfo.date, // 保存日期用于倒计时
          goTime: carInfo.goTime || '', // 保存出发时间用于倒计时
          fromLongitude: (carInfo.side === 0 && carInfo.longitude) ? carInfo.longitude : null,
          fromLatitude: (carInfo.side === 0 && carInfo.latitude) ? carInfo.latitude : null,
          fromLocationName: (carInfo.side === 0 && carInfo.locationName) ? carInfo.locationName : '',
          toLongitude: (carInfo.side === 1 && carInfo.longitude) ? carInfo.longitude : null,
          toLatitude: (carInfo.side === 1 && carInfo.latitude) ? carInfo.latitude : null,
          toLocationName: (carInfo.side === 1 && carInfo.locationName) ? carInfo.locationName : ''
        },
        // 判断是否有经纬度信息，用于控制样式和点击事件
        hasDepartureLocation: (carInfo.side === 0 && carInfo.longitude && carInfo.latitude) ? true : false,
        hasDestinationLocation: (carInfo.side === 1 && carInfo.longitude && carInfo.latitude) ? true : false,
        // 从API返回的数据读取收藏状态
        isFavorited: carInfo.isCollection === 1,
        // 保存isClub字段用于控制user-badge显示
        isClub: carInfo.isClub || 0
      });
      
      // 启动倒计时定时器
      this.startCountdownTimer();
      
      // 数据加载完成后，预先生成分享卡片
      this.generateShareCard();
      
    } else {
      // 如果传入的是ID（兼容旧逻辑），使用模拟数据
      this.updateCarpoolDetailDataWithId(carInfo);
    }
  },

  /**
   * 根据ID更新拼车详情数据（模拟数据，用于兼容）
   */
  updateCarpoolDetailDataWithId: function(id) {
    console.log('使用模拟数据更新拼车详情，ID:', id);
    
    // 模拟数据
    const mockData = {
      'demo_001': {
        tripInfo: {
          type: '前往雪场',
          serviceType: '车找人',
          time: '后天 周六 10:00',
          departure: '北京市朝阳区石佛营中水金海嘉苑',
          destination: '云顶滑雪场',
          capacity: '1人·1雪板·1板包',
          price: '¥ 113/人',
          description: '禁止携带宠物，禁止吸烟。如微信联系不上，直接电话沟通'
        }
      },
      'demo_002': {
        tripInfo: {
          type: '雪场返回',
          serviceType: '人找车',
          time: '09.25 10:00',
          departure: '云顶滑雪场',
          destination: '北京市朝阳区石佛营中水金海嘉苑',
          capacity: '1人·1雪板·1板包',
          price: '¥ 113/人',
          description: '寻找回程拼车，希望有经验丰富的司机'
        }
      },
      'demo_003': {
        tripInfo: {
          type: '雪场返回',
          serviceType: '车找人',
          time: '09.25 10:00',
          departure: '云顶滑雪场',
          destination: '北京市朝阳区石佛营中水金海嘉苑',
          capacity: '1人·1雪板·1板包',
          price: '¥ 113/人',
          description: '有车找人，欢迎拼车同行'
        }
      }
    };
    
    const data = mockData[id] || mockData['demo_001'];
    
    this.setData({
      tripInfo: data.tripInfo
    });
  },

  /**
   * 显示风险须知弹窗
   */
  showRiskNoticePopup: function() {
    this.setData({
      showRiskNoticePopup: true
    });
  },

  /**
   * 隐藏风险须知弹窗
   */
  hideRiskNoticePopup: function() {
    this.setData({
      showRiskNoticePopup: false
    });
  },

  /**
   * 阻止弹窗内容区域点击事件冒泡
   */
  preventClose: function() {
    // 阻止事件冒泡，防止点击内容区域时关闭弹窗
  },

  /**
   * 确认风险须知
   */
  confirmRiskNotice: function() {
    this.setData({
      showRiskNoticePopup: false
    });
    
    // wx.showToast({
    //   title: '已阅读风险须知',
    //   icon: 'success',
    //   duration: 1500
    // });
  },

  /**
   * 跳转到地图查看位置（出发地点）
   */
  openMapForDeparture: function() {
    const carInfo = this.data.carInfo;
    
    if (!carInfo) {
      return;
    }
    
    // 如果有经纬度信息，使用经纬度打开地图
    if (carInfo.fromLongitude && carInfo.fromLatitude) {
      wx.openLocation({
        latitude: parseFloat(carInfo.fromLatitude),
        longitude: parseFloat(carInfo.fromLongitude),
        name: this.data.tripInfo.departure || '出发地点',
        address: carInfo.fromLocationName || this.data.tripInfo.departure || '',
        success: () => {
          console.log('打开地图成功');
        },
        fail: (err) => {
          console.error('打开地图失败:', err);
          wx.showToast({
            title: '打开地图失败',
            icon: 'none'
          });
        }
      });
    } else {
      // 如果没有经纬度，尝试使用地址搜索
      wx.showToast({
        title: '暂无位置信息',
        icon: 'none'
      });
    }
  },

  /**
   * 跳转到地图查看位置（到达地点）
   */
  openMapForDestination: function() {
    const carInfo = this.data.carInfo;
    
    if (!carInfo) {
      return;
    }
    
    // 如果有经纬度信息，使用经纬度打开地图
    if (carInfo.toLongitude && carInfo.toLatitude) {
      wx.openLocation({
        latitude: parseFloat(carInfo.toLatitude),
        longitude: parseFloat(carInfo.toLongitude),
        name: this.data.tripInfo.destination || '到达地点',
        address: carInfo.toLocationName || this.data.tripInfo.destination || '',
        success: () => {
          console.log('打开地图成功');
        },
        fail: (err) => {
          console.error('打开地图失败:', err);
          wx.showToast({
            title: '打开地图失败',
            icon: 'none'
          });
        }
      });
    } else {
      // 如果没有经纬度，尝试使用地址搜索
      wx.showToast({
        title: '暂无位置信息',
        icon: 'none'
      });
    }
  }
})
